/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * OpenSceneGraph Public License for more details.
*/

#ifndef OSGDB_FILEUTILS
#define OSGDB_FILEUTILS 1

#include <BaseTool/Export>

#include <vector>
#include <deque>
#include <string>
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <algorithm>



typedef std::deque<std::string> FilePathList;

enum CaseSensitivity
{
	CASE_SENSITIVE,
	CASE_INSENSITIVE
};

namespace BaseTool {

/** Overload of the standard fopen function. If OSG_USE_UTF8_FILENAME is defined,
  * filename will be expanded from UTF8 to UTF16 and _wfopen will be called. */
	extern BaseTool_EXPORT FILE* fopen(const char* filename, const char* mode);

/** Make a new directory.  Returns true if directory exists or was created. */
	extern BaseTool_EXPORT bool makeDirectory(const std::string &directoryPath);

/** Make a new directory for a given file. */
	extern BaseTool_EXPORT bool makeDirectoryForFile(const std::string &filePath);

/** Get current working directory. */
	extern BaseTool_EXPORT std::string getCurrentWorkingDirectory(void);

	extern BaseTool_EXPORT std::string geExeDirectory(void);

/** Set current working directory. */
	extern BaseTool_EXPORT bool setCurrentWorkingDirectory(const std::string &newCurrentWorkingDirectory);



enum FileType
{
    FILE_NOT_FOUND,
    REGULAR_FILE,
    DIRECTORY
};

/** return type of file. */
extern BaseTool_EXPORT FileType fileType(const std::string& filename);

/** find specified file in specified file path.*/
extern BaseTool_EXPORT std::string findFileInPath(const std::string& filename, const FilePathList& filePath, CaseSensitivity caseSensitivity = CASE_SENSITIVE);

/** return the directory/filename of a file if its is contained within specified directory.
  * return "" if directory does not contain file.  If caseInsensitive is set to true then
  * a case insensitive comparison is used to compare fileName to directory contents.
  * This is useful when unix programs attempt read case insensitive windows filenames.
  */
extern BaseTool_EXPORT std::string findFileInDirectory(const std::string& fileName, const std::string& dirName, CaseSensitivity caseSensitivity = CASE_SENSITIVE);

/** simple list of names to represent a directory's contents. */
typedef std::vector<std::string> DirectoryContents;



/** Return the contents of a directory, sorting the names into alphabetic and numberical order.
  * Return value will contain filenames only, not absolute paths.
  * Returns an empty array on any error.*/
extern BaseTool_EXPORT DirectoryContents getSortedDirectoryContents(const std::string& dirName);

/** Return the list of filenames that match the given filename with wildcards.
  * Will only expand '*', and will not expand wildcards in directory, only in
  * filename part of the given filename.
  * Return value will contain path+filename so that if ever the above
  * limitation (expanding wildcards in directory) is fixed, client code will
  * still work unchanged. */
extern BaseTool_EXPORT DirectoryContents expandWildcardsInFilename(const std::string& filename);

namespace FileOpResult {
    enum Value
    {
        OK,                          /**< Operation done. */
        SOURCE_EQUALS_DESTINATION,   /**< Operation is useless (source == destination). */
        BAD_ARGUMENT,
        SOURCE_MISSING,              /**< Source file doesn't exist. */
        SOURCE_NOT_OPENED,           /**< Error opening source file. */
        DESTINATION_NOT_OPENED,      /**< Error opening destination file. */
        READ_ERROR,
        WRITE_ERROR
    };
}

/** Copy a file to another location, overwriting if necessary.
  * You must provide full path for both source and destination.
  * \return true on success, or if source and destination are the same.
  * \todo Replace the implementation with filesystem functions from TR2 when available.
*/
extern BaseTool_EXPORT FileOpResult::Value copyFile(const std::string & source, const std::string & destination);




/** Search for specified file in file system, checking the DataFilePathList for possible paths,
  * returning the full path of the first valid file found, return an empty string if no string is found.
  */
extern BaseTool_EXPORT std::string findDataFile(const std::string& filename, CaseSensitivity caseSensitivity = CASE_SENSITIVE);

/** Search for specified file in file system, checking first the database path set in the Options structure, then the DataFilePathList for possible paths,
  * returning the full path of the first valid file found, return an empty string if no string is found.
  */


inline void setLibraryFilePathList(const FilePathList& filepaths) { }

inline void setLibraryFilePathList(const std::string& paths) {  }



extern BaseTool_EXPORT std::string findLibraryFile(const std::string& filename, CaseSensitivity caseSensitivity = CASE_SENSITIVE);

/** convert a string containing a list of paths delimited either with ';' (Windows) or ':' (All other platforms) into FilePath representation.*/
extern BaseTool_EXPORT void convertStringPathIntoFilePathList_(const std::string& paths, FilePathList& filepath); //bylizhengjin

/** Return true if FilePathList contains a filepath that is significies checking of the current working directory.*/
extern BaseTool_EXPORT bool containsCurrentWorkingDirectoryReference(const FilePathList& paths);

extern BaseTool_EXPORT void appendPlatformSpecificLibraryFilePaths(FilePathList& filepath);
extern BaseTool_EXPORT void appendPlatformSpecificResourceFilePaths(FilePathList& filepath);

}        // namespace osgDB

using namespace BaseTool;

#endif
